Problem says: output P modulo 10^7  (= 10,000,000)
Old code used:               10^9+7 (= 1,000,000,007)  ← completely different!

Both sample answers (16 and 10000) are small enough to pass either modulus,
so the bug is invisible on samples but wrong for large exponents.

// C's standard library defines:
double exp(double x);   // Euler's e^x

// Old code used:
long long exp = t;      // Shadows the stdlib function!
// Causes undefined behavior on some compilers → wrong results

// Fix: rename to exponent
long long exponent = t;

Computing 2^13:
  13 in binary = 1 1 0 1
                 ^ ^ ^ ^
                 8 4 2 1   ← place values

  2^13 = 2^8 × 2^4 × 2^1   (skip 2^2 because bit-1 is 0)
       = 256 × 16 × 2 = 8192

Reading bits RIGHT to LEFT (low bit first):
  bit 0 = 1: result *= base(=2¹)   result=2,   base squares → 4
  bit 1 = 0: skip                  result=2,   base squares → 16
  bit 2 = 1: result *= base(=2⁴)   result=32,  base squares → 256
  bit 3 = 1: result *= base(=2⁸)   result=8192. Done!
  Total: 4 steps instead of 13!

Without mod: numbers explode immediately.
  2^63 ~ 9.2 × 10^18  ← barely fits in int64
  2^64 = OVERFLOW → garbage → wrong answer

With mod applied at each step:
  Mathematical law: (a × b) mod m = ((a mod m) × (b mod m)) mod m
  This means applying mod per step = same result as applying once at end.

  Max intermediate: (10^7 - 1)² = ~10^14 << int64_max (9.2×10^18)
  So no overflow ever occurs! 

int main() {
    long long e, t;
    scanf("%lld%lld", &e, &t);

    long long base = e % 10000000;
    // Reduce base first! e can be up to 10^12.
    // Squaring unreduced: (10^12)^2 = 10^24 → immediate overflow.
    // After mod: base < 10^7, so base^2 < 10^14 → safe in int64.

    long long exponent = t;
    // Named 'exponent', NOT 'exp' — 'exp' is C stdlib (Euler's e^x).
    // Using 'exp' as a variable name causes shadowing → undefined behavior.

    long long result = 1;
    // Start at 1 (multiplicative identity).
    // We accumulate: result = E^(bits we've processed so far).

    while (exponent > 0) {
        if (exponent & 1) {
            // Bitwise AND with 1: true if lowest bit is 1.
            // This bit's contribution: multiply result by current base.
            result = (result * base) % 10000000;
        }

        base = (base * base) % 10000000;
        // Square the base: base goes 2→4→16→256→65536→...
        // Each squaring doubles the exponent the base represents.

        exponent >>= 1;
        // Bit shift right by 1 = integer divide by 2.
        // Discards the bit we just processed, exposing the next bit.
    }

    printf("%lld\n", result);
}

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

ll modpow(ll base, ll exp, ll mod) {
    // Write your code here
}

int main() {
    ll X, N, M;
    cin >> X >> N >> M;
    
    // Write your code here
    
    return 0;
}

#include <stdio.h>

int main() {
  	long long e, t;
	scanf("%lld%lld",&e,&t);
	// compute answer
    // Fast modular exponentiation: e^t mod 10^7 (= 10000000)
    long long base = e % 10000000;
    long long exponent = t;
    long long result = 1;
    while (exponent > 0) {
        if (exponent & 1) result = (result * base) % 10000000;
        base = (base * base) % 10000000;
        exponent >>= 1;
    }
    printf("%lld\n", result);
}